home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Resources / Online / Miami / MiamiSDK / netinclude / ppcpragmas / miamipcap_pragmas.h < prev    next >
C/C++ Source or Header  |  1997-12-30  |  11KB  |  411 lines
  1. #ifndef _PPCPRAGMA_MIAMIPCAP_H
  2. #define _PPCPRAGMA_MIAMIPCAP_H
  3.  
  4. #include <net/pcap.h>
  5. #include <dos/dos.h>
  6.  
  7. #ifndef POWERUP_PPCLIB_INTERFACE_H
  8. #include <powerup/ppclib/interface.h>
  9. #endif
  10.  
  11. #ifndef POWERUP_GCCLIB_PROTOS_H
  12. #include <powerup/gcclib/powerup_protos.h>
  13. #endif
  14.  
  15. #ifndef _STRING_H
  16. #include <string.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef MIAMIPCAP_BASE_NAME
  24. #define MIAMIPCAP_BASE_NAME MiamiPCapBase
  25. #endif
  26.  
  27. #define MiamiPCapInit(m,b) _MiamiPCapInit(MIAMIPCAP_BASE_NAME,m,b)
  28.  
  29. static __inline void
  30. _MiamiPCapInit(void *MiamiPCapBase,struct Library *m,struct Library *b) {
  31.     struct Caos MyCaos;
  32.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  33.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  34.     MyCaos.a0=(ULONG)m;
  35.     MyCaos.a1=(ULONG)b;
  36.     MyCaos.caos_Un.Offset=-30;
  37.     MyCaos.a6=(ULONG)MiamiPCapBase;
  38.     PPCCallOS(&MyCaos);
  39. }
  40.  
  41. #define MiamiPCapStats(p,s) _MiamiPCapStats(MIAMIPCAP_BASE_NAME,p,s)
  42.  
  43. static __inline long
  44. _MiamiPCapStats(void *MiamiPCapBase,pcap_t *p,struct pcap_stat *s) {
  45.     struct Caos MyCaos;
  46.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  47.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  48.     MyCaos.a0=(ULONG)p;
  49.     MyCaos.a1=(ULONG)s;
  50.     MyCaos.caos_Un.Offset=-36;
  51.     MyCaos.a6=(ULONG)MiamiPCapBase;
  52.     return (long)PPCCallOS(&MyCaos);
  53. }
  54.  
  55. #define MiamiPCapOpenLive(d,s,p,t,e) _MiamiPCapOpenLive(MIAMIPCAP_BASE_NAME,d,s,p,t,e)
  56.  
  57. static __inline pcap_t *
  58. _MiamiPCapOpenLive(void *MiamiPCapBase,char *d,long s,long p,long t,char *e) {
  59.     struct Caos MyCaos;
  60.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  61.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  62.     MyCaos.a0=(ULONG)d;
  63.     MyCaos.d0=(ULONG)s;
  64.     MyCaos.d1=(ULONG)p;
  65.     MyCaos.d2=(ULONG)t;
  66.     MyCaos.a1=(ULONG)e;
  67.     MyCaos.caos_Un.Offset=-42;
  68.     MyCaos.a6=(ULONG)MiamiPCapBase;
  69.     return (pcap_t *)PPCCallOS(&MyCaos);
  70. }
  71.  
  72. #define MiamiPCapSetfilter(p,pr) _MiamiPCapSetfilter(MIAMIPCAP_BASE_NAME,p,pr)
  73.  
  74. static __inline long
  75. _MiamiPCapSetfilter(void *MiamiPCapBase,pcap_t *p,struct bpf_program *pr) {
  76.     struct Caos MyCaos;
  77.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  78.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  79.     MyCaos.a0=(ULONG)p;
  80.     MyCaos.a1=(ULONG)pr;
  81.     MyCaos.caos_Un.Offset=-48;
  82.     MyCaos.a6=(ULONG)MiamiPCapBase;
  83.     return (long)PPCCallOS(&MyCaos);
  84. }
  85.  
  86. #define MiamiPCapOpenOffline(f,e) _MiamiPCapOpenOffline(MIAMIPCAP_BASE_NAME,f,e)
  87.  
  88. static __inline pcap_t *
  89. _MiamiPCapOpenOffline(void *MiamiPCapBase,char *f,char *e) {
  90.     struct Caos MyCaos;
  91.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  92.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  93.     MyCaos.a0=(ULONG)f;
  94.     MyCaos.a1=(ULONG)e;
  95.     MyCaos.caos_Un.Offset=-54;
  96.     MyCaos.a6=(ULONG)MiamiPCapBase;
  97.     return (pcap_t *)PPCCallOS(&MyCaos);
  98. }
  99.  
  100. #define MiamiPCapAmigaDump(u,p,s) _MiamiPCapAmigaDump(MIAMIPCAP_BASE_NAME,u,p,s)
  101.  
  102. static __inline void
  103. _MiamiPCapAmigaDump(void *MiamiPCapBase,u_char *u,struct pcap_pkthdr *p,u_char *s) {
  104.     struct Caos MyCaos;
  105.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  106.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  107.     MyCaos.a0=(ULONG)u;
  108.     MyCaos.a1=(ULONG)p;
  109.     MyCaos.a2=(ULONG)s;
  110.     MyCaos.caos_Un.Offset=-60;
  111.     MyCaos.a6=(ULONG)MiamiPCapBase;
  112.     PPCCallOS(&MyCaos);
  113. }
  114.  
  115. #define MiamiPCapAmigaDumpOpen(p,f) _MiamiPCapAmigaDumpOpen(MIAMIPCAP_BASE_NAME,p,f)
  116.  
  117. static __inline pcap_dumper_t *
  118. _MiamiPCapAmigaDumpOpen(void *MiamiPCapBase,pcap_t *p,char *f) {
  119.     struct Caos MyCaos;
  120.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  121.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  122.     MyCaos.a0=(ULONG)p;
  123.     MyCaos.a1=(ULONG)f;
  124.     MyCaos.caos_Un.Offset=-66;
  125.     MyCaos.a6=(ULONG)MiamiPCapBase;
  126.     return (pcap_dumper_t *)PPCCallOS(&MyCaos);
  127. }
  128.  
  129. #define MiamiPCapAmigaDumpClose(d) _MiamiPCapAmigaClose(MIAMIPCAP_BASE_NAME,d)
  130.  
  131. static __inline void
  132. _MiamiPCapAmigaDumpClose(void *MiamiPCapBase,struct pcap_dumper_t *d) {
  133.     struct Caos MyCaos;
  134.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  135.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  136.     MyCaos.a0=(ULONG)d;
  137.     MyCaos.caos_Un.Offset=-72;
  138.     MyCaos.a6=(ULONG)MiamiPCapBase;
  139.     PPCCallOS(&MyCaos);
  140. }
  141.  
  142. #define MiamiPCapLookupdev(e) _MiamiPCapLookupdev(MIAMIPCAP_BASE_NAME,e)
  143.  
  144. static __inline char *
  145. _MiamiPCapLookupdev(void *MiamiPCapBase,char *e) {
  146.     struct Caos MyCaos;
  147.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  148.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  149.     MyCaos.a0=(ULONG)e;
  150.     MyCaos.caos_Un.Offset=-78;
  151.     MyCaos.a6=(ULONG)MiamiPCapBase;
  152.     return (char *)PPCCallOS(&MyCaos);
  153. }
  154.  
  155. #define MiamiPCapLookupnet(d,n,m,e) _MiamiPCapLookupnet(MIAMIPCAP_BASE_NAME,d,n,m,e)
  156.  
  157. static __inline long
  158. _MiamiPCapLookupnet(void *MiamiPCapBase,char *d,bpf_u_int32 *n,
  159.  bpf_u_int32 *m,char *e) {
  160.     struct Caos MyCaos;
  161.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  162.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  163.     MyCaos.a0=(ULONG)d;
  164.     MyCaos.a1=(ULONG)n;
  165.     MyCaos.a2=(ULONG)m;
  166.     MyCaos.a3=(ULONG)e;
  167.     MyCaos.caos_Un.Offset=-84;
  168.     MyCaos.a6=(ULONG)MiamiPCapBase;
  169.     return (long)PPCCallOS(&MyCaos);
  170. }
  171.  
  172. #define MiamiPCapDispatch(p,c,cb,u) _MiamiPCapDispatch(MIAMIPCAP_BASE_NAME,p,c,cb,u)
  173.  
  174. static __inline long
  175. _MiamiPCapDispatch(void *MiamiPCapBase,pcap_t *p,long c,
  176.  pcap_handler cb,u_char *u) {
  177.     struct Caos MyCaos;
  178.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  179.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  180.     MyCaos.a0=(ULONG)p;
  181.     MyCaos.d0=(ULONG)c;
  182.     MyCaos.a1=(ULONG)cb;
  183.     MyCaos.a2=(ULONG)u;
  184.     MyCaos.caos_Un.Offset=-90;
  185.     MyCaos.a6=(ULONG)MiamiPCapBase;
  186.     return (long)PPCCallOS(&MyCaos);
  187. }
  188.  
  189. #define MiamiPCapLoop(p,c,cb,u) _MiamiPCapLoop(MIAMIPCAP_BASE_NAME,p,c,cb,u)
  190.  
  191. static __inline long
  192. _MiamiPCapLoop(void *MiamiPCapBase,pcap_t *p,long c,
  193.  pcap_handler cb,u_char *u) {
  194.     struct Caos MyCaos;
  195.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  196.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  197.     MyCaos.a0=(ULONG)p;
  198.     MyCaos.d0=(ULONG)c;
  199.     MyCaos.a1=(ULONG)cb;
  200.     MyCaos.a2=(ULONG)u;
  201.     MyCaos.caos_Un.Offset=-96;
  202.     MyCaos.a6=(ULONG)MiamiPCapBase;
  203.     return (long)PPCCallOS(&MyCaos);
  204. }
  205.  
  206. #define MiamiPCapNext(p,ph) _MiamiPCapNext(MIAMIPCAP_BASE_NAME,p,ph)
  207.  
  208. static __inline const u_char *
  209. _MiamiPCapNext(void *MiamiPCapBase,pcap_t *p,struct pcap_pkthdr *ph) {
  210.     struct Caos MyCaos;
  211.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  212.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  213.     MyCaos.a0=(ULONG)p;
  214.     MyCaos.a1=(ULONG)ph;
  215.     MyCaos.caos_Un.Offset=-102;
  216.     MyCaos.a6=(ULONG)MiamiPCapBase;
  217.     return (const u_char *)PPCCallOS(&MyCaos);
  218. }
  219.  
  220. #define MiamiPCapDatalink(p) _MiamiPCapDatalink(MIAMIPCAP_BASE_NAME,p)
  221.  
  222. static __inline long
  223. _MiamiPCapDatalink(void *MiamiPCapBase,pcap_t *p) {
  224.     struct Caos MyCaos;
  225.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  226.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  227.     MyCaos.a0=(ULONG)p;
  228.     MyCaos.caos_Un.Offset=-108;
  229.     MyCaos.a6=(ULONG)MiamiPCapBase;
  230.     return (long)PPCCallOS(&MyCaos);
  231. }
  232.  
  233. #define MiamiPCapSnapshot(p) _MiamiPCapSnapshot(MIAMIPCAP_BASE_NAME,p)
  234.  
  235. static __inline long
  236. _MiamiPCapSnapshot(void *MiamiPCapBase,pcap_t *p) {
  237.     struct Caos MyCaos;
  238.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  239.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  240.     MyCaos.a0=(ULONG)p;
  241.     MyCaos.caos_Un.Offset=-114;
  242.     MyCaos.a6=(ULONG)MiamiPCapBase;
  243.     return (long)PPCCallOS(&MyCaos);
  244. }
  245.  
  246. #define MiamiPCapIsSwapped(p) _MiamiPCapIsSwapped(MIAMIPCAP_BASE_NAME,p)
  247.  
  248. static __inline long
  249. _MiamiPCapIsSwapped(void *MiamiPCapBase,pcap_t *p) {
  250.     struct Caos MyCaos;
  251.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  252.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  253.     MyCaos.a0=(ULONG)p;
  254.     MyCaos.caos_Un.Offset=-120;
  255.     MyCaos.a6=(ULONG)MiamiPCapBase;
  256.     return (long)PPCCallOS(&MyCaos);
  257. }
  258.  
  259. #define MiamiPCapMajorVersion(p) _MiamiPCapMajorVersion(MIAMIPCAP_BASE_NAME,p)
  260.  
  261. static __inline long
  262. _MiamiPCapMajorVersion(void *MiamiPCapBase,pcap_t *p) {
  263.     struct Caos MyCaos;
  264.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  265.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  266.     MyCaos.a0=(ULONG)p;
  267.     MyCaos.caos_Un.Offset=-126;
  268.     MyCaos.a6=(ULONG)MiamiPCapBase;
  269.     return (long)PPCCallOS(&MyCaos);
  270. }
  271.  
  272. #define MiamiPCapMinorVersion(p) _MiamiPCapMinorVersion(MIAMIPCAP_BASE_NAME,p)
  273.  
  274. static __inline long
  275. _MiamiPCapMinorVersion(void *MiamiPCapBase,pcap_t *p) {
  276.     struct Caos MyCaos;
  277.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  278.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  279.     MyCaos.a0=(ULONG)p;
  280.     MyCaos.caos_Un.Offset=-132;
  281.     MyCaos.a6=(ULONG)MiamiPCapBase;
  282.     return (long)PPCCallOS(&MyCaos);
  283. }
  284.  
  285. #define MiamiPCapAmigaFile(p) _MiamiPCapAmigaFile(MIAMIPCAP_BASE_NAME,p)
  286.  
  287. static __inline BPTR
  288. _MiamiPCapAmigaFile(void *MiamiPCapBase,pcap_t *p) {
  289.     struct Caos MyCaos;
  290.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  291.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  292.     MyCaos.a0=(ULONG)p;
  293.     MyCaos.caos_Un.Offset=-138;
  294.     MyCaos.a6=(ULONG)MiamiPCapBase;
  295.     return (BPTR)PPCCallOS(&MyCaos);
  296. }
  297.  
  298. #define MiamiPCapPerror(p,pr) _MiamiPCapPerror(MIAMIPCAP_BASE_NAME,p,pr)
  299.  
  300. static __inline void
  301. _MiamiPCapPerror(void *MiamiPCapBase,pcap_t *p,char *pr) {
  302.     struct Caos MyCaos;
  303.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  304.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  305.     MyCaos.a0=(ULONG)p;
  306.     MyCaos.a1=(ULONG)pr;
  307.     MyCaos.caos_Un.Offset=-144;
  308.     MyCaos.a6=(ULONG)MiamiPCapBase;
  309.     PPCCallOS(&MyCaos);
  310. }
  311.  
  312. #define MiamiPCapGeterr(p) _MiamiPCapGeterr(MIAMIPCAP_BASE_NAME,p)
  313.  
  314. static __inline char *
  315. _MiamiPCapGeterr(void *MiamiPCapBase,pcap_t *p) {
  316.     struct Caos MyCaos;
  317.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  318.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  319.     MyCaos.a0=(ULONG)p;
  320.     MyCaos.caos_Un.Offset=-150;
  321.     MyCaos.a6=(ULONG)MiamiPCapBase;
  322.     return (char *)PPCCallOS(&MyCaos);
  323. }
  324.  
  325. #define MiamiPCapStrerror(e) _MiamiPCapStrerror(MIAMIPCAP_BASE_NAME,e)
  326.  
  327. static __inline char *
  328. _MiamiPCapStrerror(void *MiamiPCapBase,long e) {
  329.     struct Caos MyCaos;
  330.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  331.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  332.     MyCaos.d0=(ULONG)e;
  333.     MyCaos.caos_Un.Offset=-156;
  334.     MyCaos.a6=(ULONG)MiamiPCapBase;
  335.     return (char *)PPCCallOS(&MyCaos);
  336. }
  337.  
  338. #define MiamiPCapClose(p) _MiamiPCapClose(MIAMIPCAP_BASE_NAME,p)
  339.  
  340. static __inline void
  341. _MiamiPCapClose(void *MiamiPCapBase,pcap_t *p) {
  342.     struct Caos MyCaos;
  343.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  344.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  345.     MyCaos.a0=(ULONG)p;
  346.     MyCaos.caos_Un.Offset=-162;
  347.     MyCaos.a6=(ULONG)MiamiPCapBase;
  348.     PPCCallOS(&MyCaos);
  349. }
  350.  
  351. #define MiamiPCapCompile(p,pr,b,o,m) _MiamiPCapCompile(MIAMIPCAP_BASE_NAME,p,pr,b,o,m)
  352.  
  353. static __inline long
  354. _MiamiPCapCompile(void *MiamiPCapBase,pcap_t *p,struct bpf_program *pr,
  355.  char *b,long o,unsigned long m) {
  356.     struct Caos MyCaos;
  357.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  358.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  359.     MyCaos.a0=(ULONG)p;
  360.     MyCaos.a1=(ULONG)pr;
  361.     MyCaos.a2=(ULONG)b;
  362.     MyCaos.d0=(ULONG)o;
  363.     MyCaos.d1=(ULONG)m;
  364.     MyCaos.caos_Un.Offset=-168;
  365.     MyCaos.a6=(ULONG)MiamiPCapBase;
  366.     return (long)PPCCallOS(&MyCaos);
  367. }
  368.  
  369. #define MiamiPCapAmigaBPFHandle(p) _MiamiPCapAmigaBPFHandle(MIAMIPCAP_BASE_NAME,p)
  370.  
  371. static __inline long
  372. _MiamiPCapAmigaBPFHandle(void *MiamiPCapBase,pcap_t *p) {
  373.     struct Caos MyCaos;
  374.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  375.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  376.     MyCaos.a0=(ULONG)p;
  377.     MyCaos.caos_Un.Offset=-174;
  378.     MyCaos.a6=(ULONG)MiamiPCapBase;
  379.     return (long)PPCCallOS(&MyCaos);
  380. }
  381.  
  382. #define MiamiPCapBPFImage(p,n) _MiamiPCapBPFImage(MIAMIPCAP_BASE_NAME,p,n)
  383.  
  384. static __inline char *
  385. _MiamiPCapBPFImage(void *MiamiPCapBase,struct bpf_insn *p,long n) {
  386.     struct Caos MyCaos;
  387.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  388.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  389.     MyCaos.a0=(ULONG)p;
  390.     MyCaos.d0=(ULONG)n;
  391.     MyCaos.caos_Un.Offset=-180;
  392.     MyCaos.a6=(ULONG)MiamiPCapBase;
  393.     return (char *)PPCCallOS(&MyCaos);
  394. }
  395.  
  396. #define MiamiPCapSetCallbackType(p,c) _MiamiPCapSetCallbackType(MIAMIPCAP_BASE_NAME,p,c)
  397.  
  398. static __inline long
  399. _MiamiPCapSetCallbackType(void *MiamiPCapBase,pcap_t *p,long c) {
  400.     struct Caos MyCaos;
  401.     MyCaos.M68kCacheMode=IF_CACHEFLUSHALL;
  402.     MyCaos.PPCCacheMode=IF_CACHEFLUSHALL;
  403.     MyCaos.a0=(ULONG)p;
  404.     MyCaos.d0=(ULONG)c;
  405.     MyCaos.caos_Un.Offset=-204;
  406.     MyCaos.a6=(ULONG)MiamiPCapBase;
  407.     return (long)PPCCallOS(&MyCaos);
  408. }
  409.  
  410. #endif
  411.